home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 8 / QRZ Ham Radio Callsign Database - Volume 8.iso / pc / files / mac / sftkisrc.hqx / SoftKiss.src.1.8 / sfk_test.c < prev    next >
Text File  |  1993-03-18  |  14KB  |  654 lines
  1. /*
  2.  * main program to test softkiss device driver
  3.  * by Aaron Wohl / N3LIW (aw0g+@andrew.cmu.edu) jul 1990
  4.  * 6393 Penn Ave #303
  5.  * Pittsburgh PA, 15206
  6.  * work: (412)-268-5032
  7.  * home: (412)-731-6159
  8.  */
  9.  
  10. #define VERS "1.6"
  11.  
  12. #include <stdlib.h>
  13. #include <stdio.h>
  14. #include <OSChecks.h>
  15. #include <ctype.h>
  16.  
  17. #define NIL 0L
  18.  
  19. #include "sfk_core.h"
  20. #include "sfk_core_private.h"
  21. #include "sfk_core_some_macs.h"
  22. #include "sfk_die.h"
  23. #include "driver_shell.h"
  24.  
  25. #define fatal_error(xx_arg) {printf xx_arg;fflush(stdout);exit(0);}
  26. extern void exit(int);
  27.  
  28. int drvr_num= (-10);
  29. static char cmd_buf[300];
  30.  
  31. #define DEFAULT_PORT (1)
  32. static int last_port=DEFAULT_PORT;
  33.  
  34. static char fix_letter(uint8 in)
  35. {
  36.     return (0x7f&(in>>1));
  37. }
  38.  
  39. /*
  40.  * test circular buffer code
  41.  */
  42. #define BUF_SIZE (10)
  43. static void cu_test(char *cmd)
  44. {
  45.     static sfk_circular_buffer cu;
  46.     switch(*cmd++) {
  47.     case 'i':
  48.         sfk_cu_init(&cu,BUF_SIZE);
  49.         break;
  50.     case 'u':
  51.         sfk_cu_uninit(&cu);
  52.         break;
  53.     case 's':
  54.         printf("size=%ld write=%ld read=%ld\n",
  55.             cu.cu_size,cu.cu_write,cu.cu_read);
  56.         printf("wsize=%ld\n",sfk_cu_write_size(&cu));
  57.         printf("rsize=%ld\n",sfk_cu_read_size(&cu));
  58.         break;
  59.     case 'w':
  60.         {
  61.             long slen=strlen(cmd);
  62.             cmd[slen++]='\n';
  63.             cmd[slen]=0;
  64.             slen=sfk_cu_write(&cu,cmd,slen);
  65.             printf("wrote %ld bytes\n",slen);
  66.         }
  67.         break;
  68.     case 'r':
  69.         {
  70.             char buf[BUF_SIZE];
  71.             long rlen=sfk_cu_read(&cu,buf,sizeof(buf));
  72.             buf[rlen]=0;
  73.             printf("read %ld bytes '%s'\n",rlen,buf);
  74.         }
  75.         break;
  76.     default:
  77.         printf("unknown circuilar buffer command\n");
  78.     }
  79. }
  80.  
  81. static void print_address(uint8 *addr)
  82. {
  83.     char buf[20];
  84.     char *o=buf;
  85.     char ch;
  86.     int ssid= (0x0f&((*(addr+6))>>1));
  87.     int len=6;
  88.     while(len-- > 0) {
  89.         ch=fix_letter(*addr++);
  90.         if(ch==' ')break;
  91.         *o++=ch;
  92.     }
  93.     *o=0;
  94.     if(ssid!=0)
  95.         sprintf(o,"-%d",ssid);
  96.     printf("%s",buf);
  97. }
  98.  
  99. static print_buf(uint8 *buf,int len)
  100. {
  101.     char out_buf[2200];
  102.     char *o=out_buf;
  103.     char ch;
  104.     int left=len;
  105.     while(left-- > 0) {
  106.         ch= *buf++;
  107.         ch&=0x7f;
  108.         if((ch==0x7f)||(ch<' ')) {
  109.             *o++='^';
  110.             if(ch==0x07f)
  111.                 ch='?';
  112.             else
  113.                 ch+='@';
  114.         }
  115.         *o++ =ch;
  116.     }
  117.     *o=0;
  118.     printf("len=%d %s\n",len,out_buf);
  119. }
  120.  
  121. static int do_ctl(sfk_io_record_pt cmd,char *in_text)
  122. {
  123.     char out_buf[4000];
  124.     int failed=TRUE;
  125.     static Handle driver_shell=0;
  126.     out_buf[0]=0;
  127.     if(driver_shell==0)
  128.         driver_shell=sh_read_in_driver_shell();
  129.     if(driver_shell==0) {
  130.         printf("can't read in driver shell\n");
  131.         return -1;
  132.     }
  133.     if(cmd->csCode==sfk_CMD_msg)
  134.       sfk_parse_from(cmd,in_text,strlen(in_text),out_buf,sizeof(out_buf),last_port);
  135.     sfk_driver((CntrlParam *)cmd,0,sh_CONTROL,driver_shell);
  136.     if(cmd->csCode==sfk_CMD_msg)
  137.         last_port=cmd->do_this.cknd.sfk_msg.portno;
  138.     if((cmd->do_this.sfk_hdr.sys_err_code!=0)||
  139.        (cmd->do_this.sfk_hdr.sfk_err_code!=0)) {
  140.         if(cmd->do_this.sfk_hdr.sfk_err_code!=sfk_NOTHING_TO_READ)
  141.                printf("ctl failed %d %d\n",
  142.                cmd->do_this.sfk_hdr.sys_err_code,cmd->do_this.sfk_hdr.sfk_err_code);
  143.     } else
  144.         failed=FALSE;
  145.     if(out_buf[0]!=0)
  146.       printf("ctloutbuf='%s'\n",out_buf);
  147.     return failed;
  148. }
  149.  
  150. static char *command_resp_names[4]={
  151.  "V1",
  152.  "R",
  153.  "C",
  154.  "V1"
  155. };
  156.  
  157. static void read_input()
  158. {
  159.     uint8 buf[4000];
  160.     uint8 *obuf;
  161.     int len;
  162.     char *via=" via ";
  163.     int command_resp;
  164.     sfk_io_record cmd;
  165.     memset(buf,0,sizeof(buf));
  166.     memset(&cmd,0,sizeof(cmd));
  167.     sfk_INIT_CPB(cmd,drvr_num,sfk_CMD_read);
  168.     cmd.do_this.cknd.sfk_rw.data= buf;
  169.     buf[0]=0;
  170.     if(do_ctl(&cmd,cmd_buf+1))
  171.         return;
  172.     printf("%d!",cmd.do_this.cknd.sfk_rw.portno);
  173.     print_address(buf+7);
  174.     printf(" > ");
  175.     print_address(buf);
  176.     printf(" ");
  177.     obuf=buf+7;
  178.     len=cmd.do_this.cknd.sfk_rw.cnt-14;
  179.     while ((len > 0) && (((*(obuf+6))&1)==0)) { /*print vias*/
  180.         obuf+=7;
  181.         printf("%s",via);
  182.         via=" ";
  183.         len-=7;
  184.         print_address(obuf);
  185.     }
  186.     command_resp=(((*(buf+6))>>6)&2)| /*dest bit*/
  187.                 (((*(buf+13))>>7)&1); /*src bit*/
  188.     printf("%s ",command_resp_names[command_resp]);
  189.     obuf+=7;
  190.     {
  191.         uint8 ctl= *obuf++;
  192.         len--;
  193.         if((ctl&1)==0) {
  194.             uint8 pid=*obuf++;
  195.             len--;
  196.             printf("Ir(%d)%ss(%d) ",    /*I (info) frame*/
  197.                 (ctl>>5)&7,
  198.                 (((ctl&0x10)!=0)?"P":""),
  199.                 (ctl>>1)&7);
  200.             if(pid==0xcc)
  201.                 printf("IP ");
  202.             else if(pid==0xcd)
  203.                 printf("ARP ");
  204.             else if(pid==0xf0)
  205.                 printf("nol3 ");
  206.             else if((pid&0x30)==0x10)
  207.                 printf("ax25 ");
  208.             else if((pid&0x30)==0x20)
  209.                 printf("ax25 ");
  210.         } else if ((ctl&2)==0)    {        /*S frame*/
  211.             char *skind=" S";
  212.             switch((ctl>>2)&3) {
  213.             case 0:
  214.                 skind="RR ";
  215.                 break;
  216.             case 1:
  217.                 skind="RNR ";
  218.                 break;
  219.             case 2:
  220.                 skind="REJ ";
  221.                 break;
  222.             default:
  223.                 break;
  224.             }
  225.             printf("%sN(%d)%s ",skind,
  226.                 ((ctl>>5)&7),
  227.                 (((ctl&0x10)!=0)?"P":""));
  228.         } else {        /*U frame*/
  229.             char *cmd_type;
  230.             switch(ctl&0xec) {
  231.             case 0x2c:
  232.                 cmd_type="SABM";
  233.                 break;
  234.             case 0x40:
  235.                 cmd_type="DISC";
  236.                 break;
  237.             case 0x0c:
  238.                 cmd_type="DM";
  239.                 break;
  240.             case 0x60:
  241.                 cmd_type="UA";
  242.                 break;
  243.             case 0x84:
  244.                 cmd_type="FRMR";
  245.                 break;
  246.             case 0x00:
  247.                 cmd_type="UI";
  248.                 break;
  249.             default:
  250.                 cmd_type="U?";
  251.             }
  252.             printf("%s ",cmd_type);
  253.         }
  254.         print_buf(obuf,len);
  255.     }
  256. }
  257.  
  258. static char get_cmd()
  259. {
  260.     switch(last_port) {
  261.     case 0:
  262.         printf("printer_");
  263.         break;
  264.     case 1:
  265.         printf("modem_");
  266.         break;
  267.     case 2:
  268.         printf("loopback_");
  269.         break;
  270.     default:
  271.         printf("port_%d_",last_port);
  272.         break;
  273.     }
  274.     printf("sfk> ");
  275.     if(gets(cmd_buf)==NIL)
  276.         return 0;
  277.     return cmd_buf[0];
  278. }
  279.  
  280. static void read_cmd(void)
  281. {
  282.     int have_wne=WNEIsImplemented();
  283.     EventRecord theEvent;
  284.     printf("click mouse to exit recieve\n");
  285.     while (TRUE ) {
  286.         if(have_wne)
  287.             if(WaitNextEvent(keyDownMask,&theEvent,10,0))
  288.                 break;
  289.         if(Button())
  290.             break;
  291.         read_input();
  292.         }
  293. }
  294.  
  295. /*
  296.  * send the passed message to the driver
  297.  */
  298. static void send_msg(char *msg)
  299. {
  300.     sfk_io_record cmd;
  301.     sfk_INIT_CPB(cmd,drvr_num,sfk_CMD_msg);
  302.     do_ctl(&cmd,msg);
  303. }
  304.  
  305. /*
  306.  * transmit the passed message on the passed port
  307.  */
  308. static void xmit_msg(char *msg,int msg_len,int portno)
  309. {
  310.     sfk_io_record cmd;
  311.     memset(&cmd,0,sizeof(cmd));
  312.     sfk_INIT_CPB(cmd,drvr_num,sfk_CMD_write);
  313.     cmd.do_this.cknd.sfk_rw.data= (void *)msg;
  314.     cmd.do_this.cknd.sfk_rw.portno= portno;
  315.     cmd.do_this.cknd.sfk_rw.cnt=msg_len;
  316.     do_ctl(&cmd,msg);
  317. }
  318.  
  319. #define AX(xx_ch) ((xx_ch)<<1)
  320. #define BL AX(' ')
  321.  
  322. static char cq_to[]={
  323.     AX('C'), AX('Q'), BL, BL, BL, BL, 0x60 /*v 2.0 resp, no reserved bits, 0 ssid*/
  324. };
  325.  
  326. static char cq_from[]={
  327.     BL, BL, BL, BL, BL, BL, 0xe1, /*V2.0 resp, no reserved bits end of addr*/
  328.     0x03,    /*unnumbered information*/
  329.     0xF0    /*no layer 3 protocol in an id packet*/
  330. };
  331.  
  332. static int nasty_chars(char *s)
  333. {
  334.     char ch;
  335.     while((ch=*s++)!=0) {
  336.         if(ch==' ')
  337.             continue;
  338.         if(ch<0) return TRUE;
  339.         if(!isalnum(ch)) return TRUE;
  340.     }
  341.     return FALSE;
  342. }
  343.  
  344. static void set_from()
  345. {
  346.     char *s=cmd_buf+1;
  347.     int clen=strlen(s);
  348.     char ch;
  349.     unsigned char *out= (unsigned char *)cq_from;
  350.     if(clen<1) {
  351.         printf("from argument too short.  usage example: Fw1aw\n");
  352.         return;
  353.     }
  354.     if(clen>6) {
  355.         printf("from argument too long.  usage example: Fw1aw\n");
  356.         return;
  357.     }
  358.     if(nasty_chars(s)) {
  359.         printf("illegal character in from.  usage example: Fw1aw\n");
  360.         return;
  361.     }
  362.     printf("new from '%s'\n",s);
  363.     memset(out,BL,6);    /*perhaps previous id was shorter*/
  364.     while(clen-- > 0) {
  365.         ch= *s++;
  366.         if(islower(ch))
  367.             ch=toupper(ch);
  368.         *out++ = AX(ch);
  369.     }
  370. }
  371.  
  372. struct out_buf_R {
  373.     char *ostr;
  374.     int max_len;
  375.     int siz;
  376. };
  377. typedef struct out_buf_R out_buf,*out_buf_pt;
  378.  
  379. static append_output(out_buf_pt ob,char *txt,int len)
  380. {
  381.     if(ob->siz+len>ob->max_len) {
  382.         printf("send string output buffer overflow, max size=%d\n",ob->max_len);
  383.         exit(1);
  384.     }
  385.     memcpy(ob->ostr+ob->siz,txt,len);
  386.     ob->siz+=len;
  387. }
  388.  
  389. /*
  390.  * transmit the passed text
  391.  */
  392. static int xmit_text(char *send_me)
  393. {
  394.     char buf[512];
  395.     out_buf ob;
  396.     ob.siz=0;
  397.     ob.max_len=sizeof(buf);
  398.     ob.ostr=buf;
  399.     if(cq_from[0]==BL) {
  400.         printf("set the callsign to send from with the F command\n");
  401.         return TRUE;
  402.     }
  403.     printf("sending '%s'\n",send_me);
  404.     append_output(&ob,cq_to,sizeof(cq_to));
  405.     append_output(&ob,cq_from,sizeof(cq_from));
  406.     append_output(&ob,send_me,strlen(send_me));
  407.     xmit_msg(ob.ostr,ob.siz,last_port);
  408.     return FALSE;
  409. }
  410.  
  411. /*
  412.  * send a message
  413.  * when transmision begins, turn off interupts for long enough to
  414.  * miss transmiting an outgoing character.  This is to test
  415.  * for how someone having interupts off for too long is handled
  416.  */
  417. #define CHARS_TO_SEND_BEFORE_LOCKOUT (14)
  418. long random_global;
  419. static void isend(void)
  420. {
  421.     sfk_prt_pt p;
  422.     if(xmit_text("softkiss interupt lockout test message 0123456789abcdefghijklmnopqrstuvwxyz"))
  423.         return;
  424.     p=sfk_PN(last_port);
  425.     // wait for xmit to start
  426.    while(p->out_count<CHARS_TO_SEND_BEFORE_LOCKOUT)
  427.         if(Button()) {
  428.             printf("isend abort by click\n");
  429.             return;
  430.             }
  431.     sfk_SCC_interupts_off;
  432.     {
  433.         long delay=0;
  434.         long delay2;
  435.         for(delay2=0;delay2<0x00300000;delay2++)
  436.                 random_global++;
  437.     }
  438.     sfk_SCC_interupts_on;
  439.     printf("woke up from lockout\n");
  440. }
  441.  
  442. /*
  443.  * send a test message
  444.  */
  445. static void xsend(void)
  446. {
  447.     if(strlen(cmd_buf+1)<1) {
  448.         printf("send with string to send. example: Shello bob\n");
  449.         return;
  450.     }
  451.     xmit_text(cmd_buf+1);
  452. }
  453.  
  454. static void dump_regs()
  455. {
  456.     sfk_prt_pt p=sfk_PN(last_port);
  457.     int i;
  458.     for(i=0;i<NUM_SCC_REGS;i++) {
  459.         printf("[%02d]=%02x ",i,p->scc_reg_cache[i]);
  460.         if((i&7)==7)
  461.           printf("\n");
  462.     }
  463. }
  464.  
  465. static char *pr_bool(int a)
  466. {
  467.     if(a) return "";
  468.     return "not ";
  469. }
  470.  
  471. static void print_available()
  472. {
  473.     printf("_SerialPower %savailable\n",pr_bool(serial_power_implemented()));
  474.     printf("_IdleState %savailable\n",pr_bool(sleep_state_implemented()));
  475.     printf("_MemoryDispatch %savailable\n",pr_bool(is_vm_manager_present()));
  476.     printf("_CacheFlushTrap %savailable\n",pr_bool(is_cache_manager_present()));
  477.     printf("Time manager version %d\n",time_manager_version());
  478. }
  479.  
  480. #define RES_FILE "\pboot:new_res"
  481. #define SOUT_SIZE (60000)
  482. #define FailOSErr(xx_test) \
  483.     do { if((xx_test)!=0) fatal_error(("os call failed "));} while(0)
  484.  
  485. static void FailResError(void)
  486. {
  487.     FailOSErr(ResError());
  488. }
  489.  
  490. int sfk_cmd_dump(int idx,char **nm_text,char **nm_help,
  491.     char **nm_default,long *nm_flags,short *nm_val_num);
  492.  
  493. unsigned short scnt;
  494. unsigned char *sbuf;
  495. unsigned char *sout;
  496. char **shandle;
  497.  
  498. static void dump_res(void)
  499. {
  500.     int idx=0;
  501.     char *nm_text;
  502.     char *nm_help;
  503.     char *nm_default;
  504.     long nm_flags;
  505.     char buf[1000];
  506.     short nm_val_num;
  507.     int len;
  508.     short imap[300];
  509.     int i;
  510.     memset(imap,-1,sizeof(imap));
  511.     while(sfk_cmd_dump(idx,&nm_text,&nm_help,&nm_default,&nm_flags,&nm_val_num)) {
  512.         if(imap[nm_val_num]!= -1)
  513.             fatal_error(("command table duplicated with %s",nm_text));
  514.         imap[nm_val_num]=idx;
  515.         idx++;
  516.     }
  517.     printf("command table size=%d\n",idx);
  518.     for(i=0;i<idx;i++) {
  519.         if(imap[i]<0)
  520.             fatal_error(("command table empty at %d %d",i,imap[i]));
  521.         if(!sfk_cmd_dump(imap[i],&nm_text,&nm_help,&nm_default,&nm_flags,&nm_val_num))
  522.             fatal_error(("command table botched"));
  523.         sprintf(buf,"%s|%s|%s|%lx",
  524.             nm_text,nm_help,nm_default,nm_flags);
  525.         len=strlen(buf);
  526.         scnt++;
  527.         *sout++=len;
  528.         memcpy(sout,buf,len);
  529.         sout+=len;
  530.     }
  531. }
  532.  
  533. static void dump_commands()
  534. {
  535.     int res_file_num=0;
  536.     scnt=0;
  537.     shandle=NewHandle(SOUT_SIZE);
  538.     if(shandle==0)
  539.         fatal_error(("allocate handle failed"));
  540.     HLock(shandle);
  541.     sbuf=(unsigned char*)StripAddress(*shandle);
  542.     sout=sbuf+2;
  543.     dump_res();
  544.     *((unsigned short *)sbuf)=scnt;
  545.  
  546.     FSDelete(RES_FILE,0);
  547.     FailOSErr(Create(RES_FILE,0,'Doug','RSRC'));
  548.     CreateResFile(RES_FILE);
  549.     FailResError();
  550.     if((res_file_num=OpenResFile((unsigned char *)StripAddress(RES_FILE)))== -1)
  551.         FailResError();
  552.     UseResFile(res_file_num);
  553.     FailResError();
  554.  
  555.     HUnlock(shandle);
  556.     SetHandleSize(shandle,sout-sbuf);
  557.     FailResError();
  558.     AddResource(shandle,'STR#',1025,"\pCommand Table");
  559.     printf("ResError()=%d\n",ResError());
  560.     CloseResFile(res_file_num);
  561.     FailResError();
  562. }
  563.  
  564. void cmd_loop(void);
  565. void cmd_loop()
  566. {
  567.     sfk_io_record cmd;
  568.     while(TRUE) {
  569.         char ch=get_cmd();
  570.         switch(ch) {
  571.         case 'W':
  572.             dump_commands();
  573.             break;
  574.         case 'C':
  575.             cu_test(cmd_buf+1);
  576.             break;
  577.         case 'A':
  578.             print_available();
  579.         case 'Q':
  580.             return;
  581.         case 'T':
  582.             printf("tick command system\n");
  583.             sfk_INIT_CPB(cmd,drvr_num,sfk_CMD_run);
  584.             do_ctl(&cmd,"");
  585.             break;
  586.         case 'S':
  587.             xsend();
  588.             break;
  589.         case 'I':
  590.             isend();
  591.             break;
  592.         case 'F':
  593.             set_from();
  594.             break;
  595.         case 'R':
  596.             read_cmd();
  597.             break;
  598.         case 'D':
  599.         {
  600.             
  601.                 while(!Button())
  602.                     printf("roll(%ld)=%ld\n",1000L,die(1000L));
  603.         }
  604.             break;            
  605.          default:
  606.              send_msg(cmd_buf);
  607.         }
  608.     }
  609. }
  610.  
  611. static void cleanup()
  612. {
  613.     send_msg("shutdown");
  614. }
  615.  
  616. static void open_res_file(void)
  617. {
  618.     short resnum=OpenResFile("\psfk_drvr.prj.rsrc");
  619.     if(resnum== -1) {
  620.         printf("can't find resource file\n");
  621.         exit(1);
  622.     }
  623.     UseResFile(resnum);
  624.     FailOSErr(ResError());
  625. }
  626.  
  627. int main()
  628. {
  629.     SetApplLimit(CurStackBase-70000L);
  630.     printf("SoftKiss test client test jig built on %s %s\n",__DATE__,__TIME__);
  631.     printf(" by Aaron Wohl / n3liw / aw0g+@andrew.cmu.edu / (412)-731-6159\n");
  632.     printf("Stackspace=%ld bytes\n",((long)StackSpace()));
  633.     printf(" test jig commands:\n");
  634.     printf(" Q - quit\n");
  635.     printf(" R - recieve, click mouse to exit\n");
  636.     printf(" F - set from example Fw1aw\n");
  637.     printf(" I - test interupt lockout during xmit\n");
  638.     printf(" S<data> - send data then recieve example: Shello how are you?\n");
  639.     printf(" all other commands passed as text to device driver\n");
  640.     printf("common commands:\n");
  641.     printf(" port printer - select printer port (port modem selects modem)\n");
  642.     printf(" online true -- turn on port with current setting\n");
  643.     printf(" online false -- turn off port\n");
  644.     printf(" kiss true -- enable kiss mode on current port\n");
  645.     printf(" help -- driver help file\n");
  646.     printf(" display [variable] -- show value or all variables\n");
  647.     printf("hold mouse down during output to pause\n");
  648.     printf("version %s\n",VERS);
  649.     _atexit(cleanup);
  650.     open_res_file();
  651.     cmd_loop();
  652.     exit(0);
  653. }
  654.